floatify.js ➔ ... ➔ parse - Code Metrics - Inspection of "recurlify" - pocketrocket/floatify - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — decomplexify (99dc56)

by Oliver

created 2019-03-01 01:17 UTC

floatify.js ➔ ... ➔ parse F

↳ Parent: floatify.js ➔ floatify

Complexity

Conditions	24
Paths	22

Size

Total Lines	97
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	40
CRAP Score	24.0082

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	24
eloc	50
c	2
b	0
f	0
nc	22
nop	1
dl	0
loc	97
ccs	40
cts	41
cp	0.9756
crap	24.0082
rs	0

How to fix Long Method Complexity

'use strict';

var floatify = function floatify(str) {
  var toFloatFormat = function toFloatFormat(str, ts, ds) {
    var string = str;
    var decimalSeparator = ds || '';

    string = string.split(ts || '').join('');
    if (decimalSeparator !== '') {
      string = string.split(decimalSeparator).join('.');
    }

    return parseFloat(string);
  };

  var parseParts = function parseParts(str, ele, count) {
    var string = str;
    var element = ele;
    var parts = string.split(element);

    for (var i = 1; i < parts.length; i++) {
      var left = parts[i - 1];
      var leftVal = parseInt(left, 10);

      if (parts[i].length === 0) {
        return Number.NaN;
      }

      if (parts[i].length === 3) {
        if (left.length > 3 && parts.length - 1 !== i) {
          return Number.NaN;
        }

        if (
          (leftVal === 0 || isNaN(leftVal) || left.length > 3)
          && parts.length - 1 === i
        ) {
          return toFloatFormat(string, '', element);
        }

        continue;
      }

      if (i < parts.length - 1) {
        // violation in midPart -> NaN
        return Number.NaN;
      }

      // violation in end -> Could be decimalSeparator
      if (count === 1) {
        return toFloatFormat(string, '', element);
      }

      return Number.NaN;
    }

    return toFloatFormat(string, element, '');
  };

  var parse = function parse(str) {
    var string = str;
    var spacePos;
    var spaceSplit;
    var spaceCount;
    var dotPos;
    var commaPos;
    var lDotPos;
    var lCommaPos;
    var dotCount;
    var commaCount;

    string = string.trim();

    // 1st dot position
    dotPos = string.indexOf('.');
    // 1st comma position
    commaPos = string.indexOf(',');
    // 1st space position
    spacePos = string.indexOf(' ');

    if (dotPos + commaPos + spacePos === -3) {
      // life is good, no separators
      return toFloatFormat(string);
    }

    spaceSplit = string.split(' ');
    spaceCount = spaceSplit.length - 1;
    dotCount = string.split('.').length - 1;
    commaCount = string.split(',').length - 1;

    // only combination of 2 separators allowed
    if (dotCount > 0 && commaCount > 0 && spaceCount > 0) {
      return Number.NaN;
    }

    // if there is any separator (space, comma, dot) found more than once,
    // all other must not be found more than once
    if (dotCount > 1 && (commaCount > 1 || spaceCount > 1)) {
      return Number.NaN;
    }
    if (commaCount > 1 && (dotCount > 1 || spaceCount > 1)) {
      return Number.NaN;
    }
    if (spaceCount > 1 && (dotCount > 1 || commaCount > 1)) {
      return Number.NaN;
    }

    if (spaceCount > 0) {
      if (!string.match(/^(\d{1,3})?(\s\d{3})*([,\.]\d+)?$/)) {
        return Number.NaN;
      }
      string = spaceSplit.join('');
    }

    if (dotPos !== -1 && commaPos !== -1) {
      // format is using dot and comma

      // last dot position
      lDotPos = string.lastIndexOf('.');
      // last comma position
      lCommaPos = string.lastIndexOf(',');

      // order of 1st dot -> comma must be same as last dot -> comma
      // 123.123.123,123 -> ok 123.123,123.123 -> not ok
      if (Math.sign(dotPos - commaPos) !== Math.sign(lDotPos - lCommaPos)) {
        return Number.NaN;
      }

      // check positions to guess the thousands separator
      if (dotPos > commaPos) {
        if (dotCount > 1) {
          return Number.NaN;
        }
        // best guess: . is thousands separator and , is decimal point
        return toFloatFormat(string, ',', '.');
      }

      if (commaCount > 1) {
        return Number.NaN;
      }
      // best guess: , is thousands separator and . is decimal point
      return toFloatFormat(string, '.', ',');
    }

    if (dotPos !== -1) {
      // only dot(s) in format
      return parseParts(string, '.', dotCount);
    }

    if (commaPos !== -1) {
      // only comma(s) in format
      return parseParts(string, ',', commaCount);
    }

    return toFloatFormat(string);
  };

  return parse(str);
};

if (typeof exports !== 'undefined') {
  if (typeof module !== 'undefined' && module.exports) {
    exports = module.exports = floatify;
  }
}


1		'use strict';
2
3	1	var floatify = function floatify(str) {
4	231	var toFloatFormat = function toFloatFormat(str, ts, ds) {
5	177	var string = str;
6	177	var decimalSeparator = ds \|\| '';
7
8	177	string = string.split(ts \|\| '').join('');
9	177	if (decimalSeparator !== '') {
10	145	string = string.split(decimalSeparator).join('.');
11		}
12
13	177	return parseFloat(string);
14		};
15
16	231	var parseParts = function parseParts(str, ele, count) {
17	124	var string = str;
18	124	var element = ele;
19	124	var parts = string.split(element);
20
21	124	for (var i = 1; i < parts.length; i++) {
22	131	var left = parts[i - 1];
23	131	var leftVal = parseInt(left, 10);
24
25	131	if (parts[i].length === 0) {
26	8	return Number.NaN;
27		}
28
29	123	if (parts[i].length === 3) {
30	31	if (left.length > 3 && parts.length - 1 !== i) {
31	2	return Number.NaN;
32		}
33
34	29	if (
35		(leftVal === 0 \|\| isNaN(leftVal) \|\| left.length > 3)
36		&& parts.length - 1 === i
37		) {
38	13	return toFloatFormat(string, '', element);
39		}
40
41	16	continue;
42		}
43
44	92	if (i < parts.length - 1) {
45		// violation in midPart -> NaN
46	12	return Number.NaN;
47		}
48
49		// violation in end -> Could be decimalSeparator
50	80	if (count === 1) {
51	76	return toFloatFormat(string, '', element);
52		}
53
54	4	return Number.NaN;
55		}
56
57	9	return toFloatFormat(string, element, '');
58		};
59
60	231	var parse = function parse(str) {
61	231	var string = str;
62		var spacePos;
63		var spaceSplit;
64		var spaceCount;
65		var dotPos;
66		var commaPos;
67		var lDotPos;
68		var lCommaPos;
69		var dotCount;
70		var commaCount;
71
72	231	string = string.trim();
73
74		// 1st dot position
75	231	dotPos = string.indexOf('.');
76		// 1st comma position
77	231	commaPos = string.indexOf(',');
78		// 1st space position
79	231	spacePos = string.indexOf(' ');
80
81	231	if (dotPos + commaPos + spacePos === -3) {
82		// life is good, no separators
83	18	return toFloatFormat(string);
84		}
85
86	213	spaceSplit = string.split(' ');
87	213	spaceCount = spaceSplit.length - 1;
88	213	dotCount = string.split('.').length - 1;
89	213	commaCount = string.split(',').length - 1;
90
91		// only combination of 2 separators allowed
92	213	if (dotCount > 0 && commaCount > 0 && spaceCount > 0) {
93	1	return Number.NaN;
94		}
95
96		// if there is any separator (space, comma, dot) found more than once,
97		// all other must not be found more than once
98	212	if (dotCount > 1 && (commaCount > 1 \|\| spaceCount > 1)) {
99	4	return Number.NaN;
100		}
101	208	if (commaCount > 1 && (dotCount > 1 \|\| spaceCount > 1)) {
102	1	return Number.NaN;
103		}
104	207	if (spaceCount > 1 && (dotCount > 1 \|\| commaCount > 1)) {
105		return Number.NaN;
106		}
107
108	207	if (spaceCount > 0) {
109	72	if (!string.match(/^(\d{1,3})?(\s\d{3})*([,\.]\d+)?$/)) {
110	17	return Number.NaN;
111		}
112	55	string = spaceSplit.join('');
113		}
114
115	190	if (dotPos !== -1 && commaPos !== -1) {
116		// format is using dot and comma
117
118		// last dot position
119	61	lDotPos = string.lastIndexOf('.');
120		// last comma position
121	61	lCommaPos = string.lastIndexOf(',');
122
123		// order of 1st dot -> comma must be same as last dot -> comma
124		// 123.123.123,123 -> ok 123.123,123.123 -> not ok
125	61	if (Math.sign(dotPos - commaPos) !== Math.sign(lDotPos - lCommaPos)) {
126	3	return Number.NaN;
127		}
128
129		// check positions to guess the thousands separator
130	58	if (dotPos > commaPos) {
131	51	if (dotCount > 1) {
132	1	return Number.NaN;
133		}
134		// best guess: . is thousands separator and , is decimal point
135	50	return toFloatFormat(string, ',', '.');
136		}
137
138	7	if (commaCount > 1) {
139	1	return Number.NaN;
140		}
141		// best guess: , is thousands separator and . is decimal point
142	6	return toFloatFormat(string, '.', ',');
143		}
144
145	129	if (dotPos !== -1) {
146		// only dot(s) in format
147	85	return parseParts(string, '.', dotCount);
148		}
149
150	44	if (commaPos !== -1) {
151		// only comma(s) in format
152	39	return parseParts(string, ',', commaCount);
153		}
154
155	5	return toFloatFormat(string);
156		};
157
158	231	return parse(str);
159		};
160
161	2	if (typeof exports !== 'undefined') {
162	4	if (typeof module !== 'undefined' && module.exports) {
163	1	exports = module.exports = floatify;
164		}
165		}
166

pocketrocket / floatify

GitHub Access Token became invalid

Branch — decomplexify (99dc56)

floatify.js ➔ ... ➔ parse F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like